//本文件由程序自动生成,请不要自行修改
using System;
using fastCSharp;

#if NotFastCSharpCode
#else
#pragma warning disable
namespace diantou.examLogServer
{
        public partial class examJudgeLog
        {
            internal static partial class tcpServer
            {
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public static diantou.examLogServer.examJudgeLog[] _M0(int userId, int problemId)
                {

                    
                    return diantou.examLogServer.examJudgeLog/**/.get(userId, problemId);
                }
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public static bool _M1(int userId, int sessionId, diantou.examLogServer.examJudgeLog[] logs)
                {

                    
                    return diantou.examLogServer.examJudgeLog/**/.append(userId, sessionId, logs);
                }
            }
        }
}namespace diantou.examLogServer
{
        /// <summary>
        /// TCP调用客户端
        /// </summary>
        public static partial class tcpCall
        {
            /// <summary>
            /// 考试编程日志
            /// </summary>
            public partial class examJudgeLog
            {
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c0 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 1 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取用户考试日志
                /// </summary>
                public static fastCSharp.net.returnValue<diantou.examLogServer.examJudgeLog[]> get(int userId, int problemId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1> _wait_ = fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1>.Get();
                    if (_wait_ != null)
                    {
                        
                        get(userId, problemId, null, _wait_, false);
                        fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {

                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1 _outputParameterValue_ = _outputParameter_.Value;
                            return _outputParameterValue_.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    else _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    return new fastCSharp.net.returnValue<diantou.examLogServer.examJudgeLog[]>{ Type = _returnType_ };
                }


                private static void get(int userId, int problemId, Action<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient _client_ = diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default;
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = _client_.StreamSocket;
                        if (_socket_ != null)
                        {
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._i1 _inputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._i1
                            {
                                userId = userId,
                                problemId = problemId,
                            };
                            
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1 _outputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1();
                            _socket_.Get(_onReturn_, _callback_, _c0, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o1>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c1 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 2 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 添加考试编程日志
                /// </summary>
                public static fastCSharp.net.returnValue<bool> append(int userId, int sessionId, diantou.examLogServer.examJudgeLog[] logs)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2> _wait_ = fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2>.Get();
                    if (_wait_ != null)
                    {
                        
                        append(userId, sessionId, logs, null, _wait_, false);
                        fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {

                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2 _outputParameterValue_ = _outputParameter_.Value;
                            return _outputParameterValue_.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    else _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private static void append(int userId, int sessionId, diantou.examLogServer.examJudgeLog[] logs, Action<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient _client_ = diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default;
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = _client_.StreamSocket;
                        if (_socket_ != null)
                        {
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._i2 _inputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._i2
                            {
                                userId = userId,
                                sessionId = sessionId,
                                logs = logs,
                            };
                            
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2 _outputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2();
                            _socket_.Get(_onReturn_, _callback_, _c1, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o2>{ Type = _returnType_ });
                }
            }
        }
}namespace diantou.examLogServer
{
        public partial class examLog
        {
            internal static partial class tcpServer
            {
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public static diantou.examLogServer.examLog[] _M2(int userId)
                {

                    
                    return diantou.examLogServer.examLog/**/.get(userId);
                }
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public static bool _M3(int userId, int sessionId, diantou.examLogServer.examLog[] logs)
                {

                    
                    return diantou.examLogServer.examLog/**/.append(userId, sessionId, logs);
                }
            }
        }
}namespace diantou.examLogServer
{
        /// <summary>
        /// TCP调用客户端
        /// </summary>
        public static partial class tcpCall
        {
            /// <summary>
            /// 考试日志
            /// </summary>
            public partial class examLog
            {
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c2 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 3 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取用户考试日志
                /// </summary>
                public static fastCSharp.net.returnValue<diantou.examLogServer.examLog[]> get(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3> _wait_ = fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3>.Get();
                    if (_wait_ != null)
                    {
                        
                        get(userId, null, _wait_, false);
                        fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {

                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3 _outputParameterValue_ = _outputParameter_.Value;
                            return _outputParameterValue_.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    else _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    return new fastCSharp.net.returnValue<diantou.examLogServer.examLog[]>{ Type = _returnType_ };
                }


                private static void get(int userId, Action<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient _client_ = diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default;
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = _client_.StreamSocket;
                        if (_socket_ != null)
                        {
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._i3 _inputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._i3
                            {
                                userId = userId,
                            };
                            
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3 _outputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3();
                            _socket_.Get(_onReturn_, _callback_, _c2, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o3>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c3 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 4 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 添加考试日志
                /// </summary>
                public static fastCSharp.net.returnValue<bool> append(int userId, int sessionId, diantou.examLogServer.examLog[] logs)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4> _wait_ = fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4>.Get();
                    if (_wait_ != null)
                    {
                        
                        append(userId, sessionId, logs, null, _wait_, false);
                        fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {

                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4 _outputParameterValue_ = _outputParameter_.Value;
                            return _outputParameterValue_.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    else _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private static void append(int userId, int sessionId, diantou.examLogServer.examLog[] logs, Action<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient _client_ = diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default;
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = _client_.StreamSocket;
                        if (_socket_ != null)
                        {
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._i4 _inputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._i4
                            {
                                userId = userId,
                                sessionId = sessionId,
                                logs = logs,
                            };
                            
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4 _outputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4();
                            _socket_.Get(_onReturn_, _callback_, _c3, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o4>{ Type = _returnType_ });
                }
            }
        }
}namespace diantou.examLogServer
{
        internal partial class tcpCallVerify
        {
            internal static partial class tcpServer
            {
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public static bool _M4(fastCSharp.net.tcp.commandServer.socket socket, ulong randomPrefix, byte[] md5Data, ref long ticks)
                {

                    
                    return diantou.examLogServer.tcpCallVerify/**/.verify(socket, randomPrefix, md5Data, ref ticks);
                }
            }
        }
}namespace diantou.examLogServer
{
        /// <summary>
        /// TCP调用客户端
        /// </summary>
        public static partial class tcpCall
        {
            /// <summary>
            /// TCP调用验证
            /// </summary>
            public partial class tcpCallVerify : fastCSharp.code.cSharp.tcpBase.ITcpClientVerifyMethod
            {
                /// <summary>
                /// TCP调用验证客户端
                /// </summary>
                /// <returns></returns>
                public bool Verify()
                {
                    return fastCSharp.net.tcp.timeVerifyServer.tcpCall<diantou.examLogServer.tcpCallVerify>.Verify(diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default, verify);
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c4 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 0 + 128, MaxInputSize = 1024, IsKeepCallback = 0, IsSendOnly = 0 };

                public static fastCSharp.net.returnValue<bool> verify(ulong randomPrefix, byte[] md5Data, ref long ticks)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0> _wait_ = fastCSharp.net.waitCall<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0>.Get();
                    if (_wait_ != null)
                    {
                        
                        verify(randomPrefix, md5Data, ref ticks, null, _wait_, false);
                        fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {

                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0 _outputParameterValue_ = _outputParameter_.Value;
                            ticks = _outputParameterValue_.ticks;
                            return _outputParameterValue_.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    else _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private static void verify(ulong randomPrefix, byte[] md5Data, ref long ticks, Action<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient _client_ = diantou.examLogServer.tcpClient/**/.ExamLog/**/.Default;
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = _client_.VerifyStreamSocket;
                        if (_socket_ != null)
                        {
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._i0 _inputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._i0
                            {
                                randomPrefix = randomPrefix,
                                md5Data = md5Data,
                                ticks = ticks,
                            };
                            
                            
                            diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0 _outputParameter_ = new diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0();
                            _outputParameter_.ticks = _inputParameter_.ticks;
                            _socket_.Get(_onReturn_, _callback_, _c4, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<diantou.examLogServer.tcpServer/**/.ExamLog/**/._o0>{ Type = _returnType_ });
                }
            }
        }
}
namespace diantou.examLogServer.tcpServer
{

        /// <summary>
        /// TCP调用服务端
        /// </summary>
        public partial class ExamLog : fastCSharp.net.tcp.commandServer
        {
            /// <summary>
            /// TCP调用服务端
            /// </summary>
            /// <param name="attribute">TCP调用服务器端配置信息</param>
            /// <param name="verify">TCP验证实例</param>
            public ExamLog(fastCSharp.code.cSharp.tcpServer attribute = null)
                : base(attribute ?? fastCSharp.code.cSharp.tcpServer.GetTcpCallConfig("ExamLog", typeof(diantou.examLogServer.tcpCallVerify)))
            {
                setCommands(5);
                identityOnCommands[verifyCommandIdentity = 0 + 128].Set(0 + 128, 1024);
                identityOnCommands[1 + 128].Set(1 + 128);
                identityOnCommands[2 + 128].Set(2 + 128);
                identityOnCommands[3 + 128].Set(3 + 128);
                identityOnCommands[4 + 128].Set(4 + 128);
            }
            /// <summary>
            /// 命令处理
            /// </summary>
            /// <param name="index"></param>
            /// <param name="socket"></param>
            /// <param name="data"></param>
            protected override void doCommand(int index, socket socket, ref subArray<byte> data)
            {
                if (index < 128) base.doCommand(index, socket, ref data);
                else
                {
                    switch (index - 128)
                    {
                        case 0: _M0(socket, ref data); return;
                        case 1: _M1(socket, ref data); return;
                        case 2: _M2(socket, ref data); return;
                        case 3: _M3(socket, ref data); return;
                        case 4: _M4(socket, ref data); return;
                        default: return;
                    }
                }
            }
            /// <summary>
            /// 忽略分组
            /// </summary>
            /// <param name="groupId">分组标识</param>
            protected override void ignoreGroup(int groupId)
            {
            }

            [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
            internal struct _i0
            {
                public ulong randomPrefix;
                public byte[] md5Data;
                public long ticks;
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
            [fastCSharp.emit.boxSerialize]
            internal struct _o0 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
            {
                public long ticks;
                [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                public bool Ret;
                public bool Return
                {
                    get { return Ret; }
                    set { Ret = value; }
                }
            }
            sealed class _s0 : fastCSharp.net.tcp.commandServer.socketCall<_s0, _i0>
            {
                private fastCSharp.net.returnValue<_o0> get()
                {
                    fastCSharp.net.returnValue.type returnType;
                    try
                    {
                        
                        bool Return;


                        
                        Return = diantou.examLogServer.tcpCallVerify/**/.tcpServer/**/._M4(socket, inputParameter.randomPrefix, inputParameter.md5Data, ref inputParameter.ticks);

                        if (Return) socket.SetVerifyMethod();
                        return new _o0
                        {
                            ticks = inputParameter.ticks,
                            Return = Return
                        };
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                    return new fastCSharp.net.returnValue<_o0>{ Type = returnType };
                }
                protected override void call()
                {
                    if (isVerify == 0) socket.SendStream(identity, flags, get());
                    fastCSharp.typePool<_s0>.PushNotNull(this);
                }
            }
            private void _M0(socket socket, ref subArray<byte> data)
            {
                fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                    try
                    {
                        _i0 inputParameter = new _i0();
                        if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                        {

                            _s0/**/.Call(socket, ref inputParameter);
                            return;
                        }
                        returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            internal struct _i1
            {
                public int userId;
                public int problemId;
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            [fastCSharp.emit.boxSerialize]
            internal struct _o1 : fastCSharp.net.asynchronousMethod.IReturnParameter<diantou.examLogServer.examJudgeLog[]>
            {
                [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                public diantou.examLogServer.examJudgeLog[] Ret;
                public diantou.examLogServer.examJudgeLog[] Return
                {
                    get { return Ret; }
                    set { Ret = value; }
                }
            }
            sealed class _s1 : fastCSharp.net.tcp.commandServer.socketCall<_s1, _i1>
            {
                private fastCSharp.net.returnValue<_o1> get()
                {
                    fastCSharp.net.returnValue.type returnType;
                    try
                    {
                        
                        diantou.examLogServer.examJudgeLog[] Return;


                        
                        Return = diantou.examLogServer.examJudgeLog/**/.tcpServer/**/._M0(inputParameter.userId, inputParameter.problemId);

                        return new _o1
                        {
                            Return = Return
                        };
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                    return new fastCSharp.net.returnValue<_o1>{ Type = returnType };
                }
                protected override void call()
                {
                    if (isVerify == 0) socket.SendStream(identity, flags, get());
                    fastCSharp.typePool<_s1>.PushNotNull(this);
                }
            }
            private void _M1(socket socket, ref subArray<byte> data)
            {
                fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                    try
                    {
                        _i1 inputParameter = new _i1();
                        if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                        {

                            fastCSharp.threading.task.Tiny.Add(_s1/**/.GetCall(socket, ref inputParameter));
                            return;
                        }
                        returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            internal struct _i2
            {
                public int userId;
                public int sessionId;
                public diantou.examLogServer.examJudgeLog[] logs;
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            [fastCSharp.emit.boxSerialize]
            internal struct _o2 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
            {
                [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                public bool Ret;
                public bool Return
                {
                    get { return Ret; }
                    set { Ret = value; }
                }
            }
            sealed class _s2 : fastCSharp.net.tcp.commandServer.socketCall<_s2, _i2>
            {
                private fastCSharp.net.returnValue<_o2> get()
                {
                    fastCSharp.net.returnValue.type returnType;
                    try
                    {
                        
                        bool Return;


                        
                        Return = diantou.examLogServer.examJudgeLog/**/.tcpServer/**/._M1(inputParameter.userId, inputParameter.sessionId, inputParameter.logs);

                        return new _o2
                        {
                            Return = Return
                        };
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                    return new fastCSharp.net.returnValue<_o2>{ Type = returnType };
                }
                protected override void call()
                {
                    if (isVerify == 0) socket.SendStream(identity, flags, get());
                    fastCSharp.typePool<_s2>.PushNotNull(this);
                }
            }
            private void _M2(socket socket, ref subArray<byte> data)
            {
                fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                    try
                    {
                        _i2 inputParameter = new _i2();
                        if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                        {

                            fastCSharp.threading.task.Tiny.Add(_s2/**/.GetCall(socket, ref inputParameter));
                            return;
                        }
                        returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            internal struct _i3
            {
                public int userId;
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            [fastCSharp.emit.boxSerialize]
            internal struct _o3 : fastCSharp.net.asynchronousMethod.IReturnParameter<diantou.examLogServer.examLog[]>
            {
                [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                public diantou.examLogServer.examLog[] Ret;
                public diantou.examLogServer.examLog[] Return
                {
                    get { return Ret; }
                    set { Ret = value; }
                }
            }
            sealed class _s3 : fastCSharp.net.tcp.commandServer.socketCall<_s3, _i3>
            {
                private fastCSharp.net.returnValue<_o3> get()
                {
                    fastCSharp.net.returnValue.type returnType;
                    try
                    {
                        
                        diantou.examLogServer.examLog[] Return;


                        
                        Return = diantou.examLogServer.examLog/**/.tcpServer/**/._M2(inputParameter.userId);

                        return new _o3
                        {
                            Return = Return
                        };
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                    return new fastCSharp.net.returnValue<_o3>{ Type = returnType };
                }
                protected override void call()
                {
                    if (isVerify == 0) socket.SendStream(identity, flags, get());
                    fastCSharp.typePool<_s3>.PushNotNull(this);
                }
            }
            private void _M3(socket socket, ref subArray<byte> data)
            {
                fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                    try
                    {
                        _i3 inputParameter = new _i3();
                        if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                        {

                            fastCSharp.threading.task.Tiny.Add(_s3/**/.GetCall(socket, ref inputParameter));
                            return;
                        }
                        returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            internal struct _i4
            {
                public int userId;
                public int sessionId;
                public diantou.examLogServer.examLog[] logs;
            }
            [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
            [fastCSharp.emit.boxSerialize]
            internal struct _o4 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
            {
                [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                public bool Ret;
                public bool Return
                {
                    get { return Ret; }
                    set { Ret = value; }
                }
            }
            sealed class _s4 : fastCSharp.net.tcp.commandServer.socketCall<_s4, _i4>
            {
                private fastCSharp.net.returnValue<_o4> get()
                {
                    fastCSharp.net.returnValue.type returnType;
                    try
                    {
                        
                        bool Return;


                        
                        Return = diantou.examLogServer.examLog/**/.tcpServer/**/._M3(inputParameter.userId, inputParameter.sessionId, inputParameter.logs);

                        return new _o4
                        {
                            Return = Return
                        };
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                    return new fastCSharp.net.returnValue<_o4>{ Type = returnType };
                }
                protected override void call()
                {
                    if (isVerify == 0) socket.SendStream(identity, flags, get());
                    fastCSharp.typePool<_s4>.PushNotNull(this);
                }
            }
            private void _M4(socket socket, ref subArray<byte> data)
            {
                fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                    try
                    {
                        _i4 inputParameter = new _i4();
                        if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                        {

                            fastCSharp.threading.task.Tiny.Add(_s4/**/.GetCall(socket, ref inputParameter));
                            return;
                        }
                        returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                    }
                    catch (Exception error)
                    {
                        returnType = fastCSharp.net.returnValue.type.ServerException;
                        fastCSharp.log.Error.Add(error, null, true);
                    }
                socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
            }
        }
}
namespace diantou.examLogServer.tcpClient
{

        /// <summary>
        /// TCP调用客户端
        /// </summary>
        public class ExamLog
        {
            /// <summary>
            /// 默认TCP调用服务器端配置信息
            /// </summary>
            protected internal static readonly fastCSharp.code.cSharp.tcpServer defaultTcpServer;
            /// <summary>
            /// 默认客户端TCP调用
            /// </summary>
            public static readonly fastCSharp.net.tcp.commandClient Default;
            static ExamLog()
            {
                defaultTcpServer = fastCSharp.code.cSharp.tcpServer.GetTcpCallConfig("ExamLog", typeof(diantou.examLogServer.tcpCallVerify));
                if (defaultTcpServer.IsServer) fastCSharp.log.Error.Add("请确认 ExamLog 服务器端是否本地调用", null, false);
                Default = new fastCSharp.net.tcp.commandClient(defaultTcpServer, 28, new diantou.examLogServer.tcpCall.tcpCallVerify());
                if (fastCSharp.config.appSetting.IsCheckMemory) checkMemory.Add(typeof(ExamLog));
            }
            /// <summary>
            /// 忽略TCP分组
            /// </summary>
            /// <param name="groupId">分组标识</param>
            /// <returns>是否调用成功</returns>
            public static fastCSharp.net.returnValue.type TcpIgnoreGroup(int groupId)
            {
                fastCSharp.net.tcp.commandClient client = Default;
                return client == null ? fastCSharp.net.returnValue.type.ClientDisposed : client.IgnoreGroup(groupId);
            }
        }
}
#endif